#include "aespectrumprivatedefine.h"

namespace DataSpecificationGW
{
    AEAmpExtInformationPrivate::AEAmpExtInformationPrivate()
    {
        ucAmpUnit = 6;
        fAmpLowerLimit = 0;
        fAmpUpperLimit = 0;
        ucAESensorType = 255;
        iDataPoint = 0;
        fSystemFrequency = 0;
        ucFrequencyBand = 255;
        fFrequencyLowerLimit = 0;
        fFequencyUpperLimit = 0;
        fTriggerThreshold = 0;
        sOpenTime = 0;
        sShutTime = 0;
        sMaxIntervalTime = 0;
        sGain = 60;
        ucSyncSource = 1;
        ucSyncState = 0;
        fSyncFrequency = -1;      
        ucDischargeSeverity = 0;

        reset();
    }

    void AEAmpExtInformationPrivate::reset()
    {
        bSkipAmpUnit = false;
        bHasAmpUnit = false;

        bSkipAmpLowerLimit = false;
        bHasAmpLowerLimit = false;

        bSkipAmpUpperLimit = false;
        bHasAmpUpperLimit = false;

        bSkipAESensorType = false;
        bHasAESensorType = false;

        bSkipDataPoint = false;
        bHasDataPoint = false;

        bSkipSystemFrequency = false;
        bHasSystemFrequency = false;

        bSkipPDTypeProbability = false;
        bHasPDTypeProbability = false;

        bSkipFrequencyBand = false;
        bHasFrequencyBand = false;

        bSkipFrequencyLowerLimit = false;
        bHasFrequencyLowerLimit = false;

        bSkipFequencyUpperLimit = false;
        bHasFequencyUpperLimit = false;

        bSkipBGFileName = false;
        bHasBGFileName = false;

        bSkipTriggerThreshold = false;
        bHasTriggerThreshold = false;

        bSkipOpenTime = false;
        bHasOpenTime = false;

        bSkipShutTime = false;
        bHasShutTime = false;

        bSkipMaxIntervalTime = false;
        bHasMaxIntervalTime = false;

        bSkipGain = false;
        bHasGain = false;

        bSkipSyncSource = false;
        bHasSyncSource = false;

        bSkipSyncState = false;
        bHasSyncState = false;

        bSkipSyncFrequency = false;
        bHasSyncFrequency = false;

        bSkipDischargeSeverity = false;
        bHasDischargeSeverity = false;
    }

    AEAmpExtInformationPrivate& AEAmpExtInformationPrivate::operator=(const AEAmpExtInformationPrivate& stAEAmpExtInformationPrivate)
    {
        this->ucAmpUnit = stAEAmpExtInformationPrivate.ucAmpUnit;
        this->fAmpLowerLimit = stAEAmpExtInformationPrivate.fAmpLowerLimit;
        this->fAmpUpperLimit = stAEAmpExtInformationPrivate.fAmpUpperLimit;
        this->ucAESensorType = stAEAmpExtInformationPrivate.ucAESensorType;
        this->iDataPoint = stAEAmpExtInformationPrivate.iDataPoint;
        this->fSystemFrequency = stAEAmpExtInformationPrivate.fSystemFrequency;
        this->vecPDTypeProbability = stAEAmpExtInformationPrivate.vecPDTypeProbability;
        this->ucFrequencyBand = stAEAmpExtInformationPrivate.ucFrequencyBand;
        this->fFrequencyLowerLimit = stAEAmpExtInformationPrivate.fFrequencyLowerLimit;
        this->fFequencyUpperLimit = stAEAmpExtInformationPrivate.fFequencyUpperLimit;
        this->qstrBGFileName = stAEAmpExtInformationPrivate.qstrBGFileName;
        this->fTriggerThreshold = stAEAmpExtInformationPrivate.fTriggerThreshold;
        this->sOpenTime = stAEAmpExtInformationPrivate.sOpenTime;
        this->sShutTime = stAEAmpExtInformationPrivate.sShutTime;
        this->sMaxIntervalTime = stAEAmpExtInformationPrivate.sMaxIntervalTime;
        this->sGain = stAEAmpExtInformationPrivate.sGain;
        this->ucSyncSource = stAEAmpExtInformationPrivate.ucSyncSource;
        this->ucSyncState = stAEAmpExtInformationPrivate.ucSyncState;
        this->fSyncFrequency = stAEAmpExtInformationPrivate.fSyncFrequency;
        this->ucDischargeSeverity = stAEAmpExtInformationPrivate.ucDischargeSeverity;
        return *this;
    }

    bool AEAmpExtInformationPrivate::operator==(const AEAmpExtInformationPrivate& stAEAmpExtInformationPrivate) const
    {
        if (!(this->ucAmpUnit == stAEAmpExtInformationPrivate.ucAmpUnit)) return false;
        if (!qFuzzyCompare(this->fAmpLowerLimit, stAEAmpExtInformationPrivate.fAmpLowerLimit)) return false;
        if (!qFuzzyCompare(this->fAmpUpperLimit, stAEAmpExtInformationPrivate.fAmpUpperLimit)) return false;
        if (!(this->ucAESensorType == stAEAmpExtInformationPrivate.ucAESensorType)) return false;
        if (!(this->iDataPoint == stAEAmpExtInformationPrivate.iDataPoint)) return false;
        if (!qFuzzyCompare(this->fSystemFrequency, stAEAmpExtInformationPrivate.fSystemFrequency)) return false;
        if (!(this->vecPDTypeProbability == stAEAmpExtInformationPrivate.vecPDTypeProbability)) return false;
        if (!(this->ucFrequencyBand == stAEAmpExtInformationPrivate.ucFrequencyBand)) return false;
        if (!qFuzzyCompare(this->fFrequencyLowerLimit, stAEAmpExtInformationPrivate.fFrequencyLowerLimit)) return false;
        if (!qFuzzyCompare(this->fFequencyUpperLimit, stAEAmpExtInformationPrivate.fFequencyUpperLimit)) return false;
        if (!(this->qstrBGFileName == stAEAmpExtInformationPrivate.qstrBGFileName)) return false;
        if (!qFuzzyCompare(this->fTriggerThreshold, stAEAmpExtInformationPrivate.fTriggerThreshold)) return false;
        if (!(this->sOpenTime == stAEAmpExtInformationPrivate.sOpenTime)) return false;
        if (!(this->sShutTime == stAEAmpExtInformationPrivate.sShutTime)) return false;
        if (!(this->sMaxIntervalTime == stAEAmpExtInformationPrivate.sMaxIntervalTime)) return false;
        if (!(this->sGain == stAEAmpExtInformationPrivate.sGain)) return false;
        if (!(this->ucSyncSource == stAEAmpExtInformationPrivate.ucSyncSource)) return false;
        if (!(this->ucSyncState == stAEAmpExtInformationPrivate.ucSyncState)) return false;
        if (!qFuzzyCompare(this->fSyncFrequency, stAEAmpExtInformationPrivate.fSyncFrequency)) return false;
        if (!(this->ucDischargeSeverity == stAEAmpExtInformationPrivate.ucDischargeSeverity)) return false;
        return true;
    }


    AEAmpDataPrivate::AEAmpDataPrivate()
    {
        fSignalMax = 0;
        bSignalMax = false;
        bHasSignalMax = false;

        fSignalRMS = 0;
        bSkipSignalRMS = false;
        bHasSignalRMS = false;

        fFrequencyComponent1 = 0;
        bSkipFrequencyComponent1 = false;
        bHasFrequencyComponent1 = false;

        fFrequencyComponent2 = 0;
        bSkipFrequencyComponent2 = false;
        bHasFrequencyComponent2 = false;

        fBGSignalMax = 0;
        bSkipBGSignalMax = false;
        bHasBGSignalMax = false;

        fBGSignalRMS = 0;
        bSkipBGSignalRMS = false;
        bHasBGSignalRMS = false;

        fBGFrequencyComponent1 = 0;
        bSkipBGFrequencyComponent1 = false;
        bHasBGFrequencyComponent1 = false;

        fBGFrequencyComponent2 = 0;
        bSkipBGFrequencyComponent2 = false;
        bHasBGFrequencyComponent2 = false;
    }

    AEAmpDataPrivate& AEAmpDataPrivate::operator=(const AEAmpDataPrivate& stAEAmpDataPrivate)
    {
        this->fSignalMax = stAEAmpDataPrivate.fSignalMax;
        this->fSignalRMS = stAEAmpDataPrivate.fSignalRMS;
        this->fFrequencyComponent1 = stAEAmpDataPrivate.fFrequencyComponent1;
        this->fFrequencyComponent2 = stAEAmpDataPrivate.fFrequencyComponent2;
        this->fBGSignalMax = stAEAmpDataPrivate.fBGSignalMax;
        this->fBGSignalRMS = stAEAmpDataPrivate.fBGSignalRMS;
        this->fBGFrequencyComponent1 = stAEAmpDataPrivate.fBGFrequencyComponent1;
        this->fBGFrequencyComponent2 = stAEAmpDataPrivate.fBGFrequencyComponent2;
        return *this;
    }

    bool AEAmpDataPrivate::operator==(const AEAmpDataPrivate& stAEAmpDataPrivate) const
    {
        if (!qFuzzyCompare(this->fSignalMax, stAEAmpDataPrivate.fSignalMax)) return false;
        if (!qFuzzyCompare(this->fSignalRMS, stAEAmpDataPrivate.fSignalRMS)) return false;
        if (!qFuzzyCompare(this->fFrequencyComponent1, stAEAmpDataPrivate.fFrequencyComponent1)) return false;
        if (!qFuzzyCompare(this->fFrequencyComponent2, stAEAmpDataPrivate.fFrequencyComponent2)) return false;
        if (!qFuzzyCompare(this->fBGSignalMax, stAEAmpDataPrivate.fBGSignalMax)) return false;
        if (!qFuzzyCompare(this->fBGSignalRMS, stAEAmpDataPrivate.fBGSignalRMS)) return false;
        if (!qFuzzyCompare(this->fBGFrequencyComponent1, stAEAmpDataPrivate.fBGFrequencyComponent1)) return false;
        if (!qFuzzyCompare(this->fBGFrequencyComponent2, stAEAmpDataPrivate.fBGFrequencyComponent2)) return false;
        return true;
    }


    //////////////////////////////////////////////////////////////////////////
    // AEPhase

    AEPhaseExtInformationPrivate::AEPhaseExtInformationPrivate()
    {
        ucAmpUnit = 6;
        fAmpLowerLimit = 0;
        fAmpUpperLimit = 0;
        ucAESensorType = 255;
        iDataPoint = 0;
        fTriggerThreshold = 0;
        sOpenTime = 0;
        sShutTime = 0;
        sMaxIntervalTime = 0;
        sGain = 60;
        ucSyncSource = 1;
        ucSyncState = 0;
        fSyncFrequency = -1;    
        ucDischargeSeverity = 0;

        reset();
    }

    void AEPhaseExtInformationPrivate::reset()
    {
        bSkipAmpUnit = false;
        bHasAmpUnit = false;

        bSkipAmpLowerLimit = false;
        bHasAmpLowerLimit = false;

        bSkipAmpUpperLimit = false;
        bHasAmpUpperLimit = false;

        bSkipAESensorType = false;
        bHasAESensorType = false;

        bSkipDataPoint = false;
        bHasDataPoint = false;

        bSkipPDTypeProbability = false;
        bHasPDTypeProbability = false;

        bSkipTriggerThreshold = false;
        bHasTriggerThreshold = false;

        bSkipOpenTime = false;
        bHasOpenTime = false;

        bSkipShutTime = false;
        bHasShutTime = false;

        bSkipMaxIntervalTime = false;
        bHasMaxIntervalTime = false;

        bSkipGain = false;
        bHasGain = false;

        bSkipSyncSource = false;
        bHasSyncSource = false;

        bSkipSyncState = false;
        bHasSyncState = false;

        bSkipSyncFrequency = false;
        bHasSyncFrequency = false;

        bSkipDischargeSeverity = false;
        bHasDischargeSeverity = false;
    }

    AEPhaseExtInformationPrivate& AEPhaseExtInformationPrivate::operator=(const AEPhaseExtInformationPrivate& stAEPhaseExtInformationPrivate)
    {
        this->ucAmpUnit = stAEPhaseExtInformationPrivate.ucAmpUnit;
        this->fAmpLowerLimit = stAEPhaseExtInformationPrivate.fAmpLowerLimit;
        this->fAmpUpperLimit = stAEPhaseExtInformationPrivate.fAmpUpperLimit;
        this->ucAESensorType = stAEPhaseExtInformationPrivate.ucAESensorType;
        this->iDataPoint = stAEPhaseExtInformationPrivate.iDataPoint;
        this->vecPDTypeProbability = stAEPhaseExtInformationPrivate.vecPDTypeProbability;
        this->fTriggerThreshold = stAEPhaseExtInformationPrivate.fTriggerThreshold;
        this->sOpenTime = stAEPhaseExtInformationPrivate.sOpenTime;
        this->sShutTime = stAEPhaseExtInformationPrivate.sShutTime;
        this->sMaxIntervalTime = stAEPhaseExtInformationPrivate.sMaxIntervalTime;
        this->sGain = stAEPhaseExtInformationPrivate.sGain;
        this->ucSyncSource = stAEPhaseExtInformationPrivate.ucSyncSource;
        this->ucSyncState = stAEPhaseExtInformationPrivate.ucSyncState;
        this->fSyncFrequency = stAEPhaseExtInformationPrivate.fSyncFrequency;
        this->ucDischargeSeverity = stAEPhaseExtInformationPrivate.ucDischargeSeverity;
        return *this;
    }

    bool AEPhaseExtInformationPrivate::operator==(const AEPhaseExtInformationPrivate& stAEPhaseExtInformationPrivate) const
    {
        if (!(this->ucAmpUnit == stAEPhaseExtInformationPrivate.ucAmpUnit)) return false;
        if (!qFuzzyCompare(this->fAmpLowerLimit, stAEPhaseExtInformationPrivate.fAmpLowerLimit)) return false;
        if (!qFuzzyCompare(this->fAmpUpperLimit, stAEPhaseExtInformationPrivate.fAmpUpperLimit)) return false;
        if (!(this->ucAESensorType == stAEPhaseExtInformationPrivate.ucAESensorType)) return false;
        if (!(this->iDataPoint == stAEPhaseExtInformationPrivate.iDataPoint)) return false;
        if (!(this->vecPDTypeProbability == stAEPhaseExtInformationPrivate.vecPDTypeProbability)) return false;
        if (!qFuzzyCompare(this->fTriggerThreshold, stAEPhaseExtInformationPrivate.fTriggerThreshold)) return false;
        if (!(this->sOpenTime == stAEPhaseExtInformationPrivate.sOpenTime)) return false;
        if (!(this->sShutTime == stAEPhaseExtInformationPrivate.sShutTime)) return false;
        if (!(this->sMaxIntervalTime == stAEPhaseExtInformationPrivate.sMaxIntervalTime)) return false;
        if (!(this->sGain == stAEPhaseExtInformationPrivate.sGain)) return false;
        if (!(this->ucSyncSource == stAEPhaseExtInformationPrivate.ucSyncSource)) return false;
        if (!(this->ucSyncState == stAEPhaseExtInformationPrivate.ucSyncState)) return false;
        if (!qFuzzyCompare(this->fSyncFrequency, stAEPhaseExtInformationPrivate.fSyncFrequency)) return false;
        if (!(this->ucDischargeSeverity == stAEPhaseExtInformationPrivate.ucDischargeSeverity)) return false;
        return true;
    }

    AEPhaseDataPrivate::AEPhaseDataPrivate()
    {
        bSkipAEPhaseSpectrumData = false;
        bHasAEPhaseSpectrumData = false;
    }

    AEPhaseDataPrivate& AEPhaseDataPrivate::operator=(const AEPhaseDataPrivate& stAEPhaseDataPrivate)
    {
        this->qbaAEPhaseData = stAEPhaseDataPrivate.qbaAEPhaseData;
        return *this;
    }

    bool AEPhaseDataPrivate::operator==(const AEPhaseDataPrivate& stAEPhaseDataPrivate) const
    {
        if (!(this->qbaAEPhaseData == stAEPhaseDataPrivate.qbaAEPhaseData)) return false;
        return true;
    }


    //////////////////////////////////////////////////////////////////////////
    // AEPulse

    AEPulseExtInformationPrivate::AEPulseExtInformationPrivate()
    {
        ucAmpUnit = 6;
        fAmpLowerLimit = 0;
        fAmpUpperLimit = 0;
        ucAESensorType = 255;
        iDataPoint = 0;
        fTriggerThreshold = 0;
        sOpenTime = 0;
        sShutTime = 0;
        sMaxIntervalTime = 0;
        sGain = 60;
        ucSyncSource = 1;
        ucSyncState = 0;
        fSyncFrequency = -1;
        ucDischargeSeverity = 0;

        reset();
    }

    void AEPulseExtInformationPrivate::reset()
    {
        bSkipAmpUnit = false;
        bHasAmpUnit = false;

        bSkipAmpLowerLimit = false;
        bHasAmpLowerLimit = false;

        bSkipAmpUpperLimit = false;
        bHasAmpUpperLimit = false;

        bSkipAESensorType = false;
        bHasAESensorType = false;

        bSkipPulseIntervalTimeUint = false;
        bHasPulseIntervalTimeUint = false;

        bSkipDataPoint = false;
        bHasDataPoint = false;

        bSkipPDTypeProbability = false;
        bHasPDTypeProbability = false;

        bSkipTriggerThreshold = false;
        bHasTriggerThreshold = false;

        bSkipOpenTime = false;
        bHasOpenTime = false;

        bSkipShutTime = false;
        bHasShutTime = false;

        bSkipMaxIntervalTime = false;
        bHasMaxIntervalTime = false;

        bSkipGain = false;
        bHasGain = false;

        bSkipSyncSource = false;
        bHasSyncSource = false;

        bSkipSyncState = false;
        bHasSyncState = false;

        bSkipSyncFrequency = false;
        bHasSyncFrequency = false;

        bSkipDischargeSeverity = false;
        bHasDischargeSeverity = false;
    }

    AEPulseExtInformationPrivate& AEPulseExtInformationPrivate::operator=(const AEPulseExtInformationPrivate& stAEPulseExtInformationPrivate)
    {
        this->ucAmpUnit = stAEPulseExtInformationPrivate.ucAmpUnit;
        this->fAmpLowerLimit = stAEPulseExtInformationPrivate.fAmpLowerLimit;
        this->fAmpUpperLimit = stAEPulseExtInformationPrivate.fAmpUpperLimit;
        this->ucAESensorType = stAEPulseExtInformationPrivate.ucAESensorType;
        this->ucPulseIntervalTimeUint = stAEPulseExtInformationPrivate.ucPulseIntervalTimeUint;
        this->iDataPoint = stAEPulseExtInformationPrivate.iDataPoint;
        this->vecPDTypeProbability = stAEPulseExtInformationPrivate.vecPDTypeProbability;
        this->fTriggerThreshold = stAEPulseExtInformationPrivate.fTriggerThreshold;
        this->sOpenTime = stAEPulseExtInformationPrivate.sOpenTime;
        this->sShutTime = stAEPulseExtInformationPrivate.sShutTime;
        this->sMaxIntervalTime = stAEPulseExtInformationPrivate.sMaxIntervalTime;
        this->sGain = stAEPulseExtInformationPrivate.sGain;
        this->ucSyncSource = stAEPulseExtInformationPrivate.ucSyncSource;
        this->ucSyncState = stAEPulseExtInformationPrivate.ucSyncState;
        this->fSyncFrequency = stAEPulseExtInformationPrivate.fSyncFrequency;
        this->ucDischargeSeverity = stAEPulseExtInformationPrivate.ucDischargeSeverity;
        return *this;
    }

    bool AEPulseExtInformationPrivate::operator==(const AEPulseExtInformationPrivate& stAEPulseExtInformationPrivate) const
    {
        if (!(this->ucAmpUnit == stAEPulseExtInformationPrivate.ucAmpUnit)) return false;
        if (!qFuzzyCompare(this->fAmpLowerLimit, stAEPulseExtInformationPrivate.fAmpLowerLimit)) return false;
        if (!qFuzzyCompare(this->fAmpUpperLimit, stAEPulseExtInformationPrivate.fAmpUpperLimit)) return false;
        if (!(this->ucAESensorType == stAEPulseExtInformationPrivate.ucAESensorType)) return false;
        if (!(this->ucPulseIntervalTimeUint == stAEPulseExtInformationPrivate.ucPulseIntervalTimeUint)) return false;
        if (!(this->iDataPoint == stAEPulseExtInformationPrivate.iDataPoint)) return false;
        if (!(this->vecPDTypeProbability == stAEPulseExtInformationPrivate.vecPDTypeProbability)) return false;
        if (!qFuzzyCompare(this->fTriggerThreshold, stAEPulseExtInformationPrivate.fTriggerThreshold)) return false;
        if (!(this->sOpenTime == stAEPulseExtInformationPrivate.sOpenTime)) return false;
        if (!(this->sShutTime == stAEPulseExtInformationPrivate.sShutTime)) return false;
        if (!(this->sMaxIntervalTime == stAEPulseExtInformationPrivate.sMaxIntervalTime)) return false;
        if (!(this->sGain == stAEPulseExtInformationPrivate.sGain)) return false;
        if (!(this->ucSyncSource == stAEPulseExtInformationPrivate.ucSyncSource)) return false;
        if (!(this->ucSyncState == stAEPulseExtInformationPrivate.ucSyncState)) return false;
        if (!qFuzzyCompare(this->fSyncFrequency, stAEPulseExtInformationPrivate.fSyncFrequency)) return false;
        if (!(this->ucDischargeSeverity == stAEPulseExtInformationPrivate.ucDischargeSeverity)) return false;
        return true;
    }

    AEPulseDataPrivate::AEPulseDataPrivate()
    {
        bSkipAEPulseSpectrumData = false;
        bHasAEPulseSpectrumData = false;
    }

    AEPulseDataPrivate& AEPulseDataPrivate::operator=(const AEPulseDataPrivate& stAEPulseDataPrivate)
    {
        this->qbaAEPulseData = stAEPulseDataPrivate.qbaAEPulseData;
        return *this;
    }

    bool AEPulseDataPrivate::operator==(const AEPulseDataPrivate& stAEPulseDataPrivate) const
    {
        if (!(this->qbaAEPulseData == stAEPulseDataPrivate.qbaAEPulseData)) return false;
        return true;
    }


    //////////////////////////////////////////////////////////////////////////
    // AEWave

    AEWaveExtInformationPrivate::AEWaveExtInformationPrivate()
    {
        ucAmpUnit = 6;
        fAmpLowerLimit = 0;
        fAmpUpperLimit = 0;
        ucAESensorType = 255;
        iDataPoint = 0;
        fTriggerThreshold = 0;
        sOpenTime = 0;
        sShutTime = 0;
        sMaxIntervalTime = 0;
        sGain = 60;
        ucSyncSource = 1;
        ucSyncState = 0;
        fSyncFrequency = -1;
        ucDischargeSeverity = 0;

        reset();
    }

    void AEWaveExtInformationPrivate::reset()
    {
        bSkipAmpUnit = false;
        bHasAmpUnit = false;

        bSkipAmpLowerLimit = false;
        bHasAmpLowerLimit = false;

        bSkipAmpUpperLimit = false;
        bHasAmpUpperLimit = false;

        bSkipAESensorType = false;
        bHasAESensorType = false;

        bSkipDataPoint = false;
        bHasDataPoint = false;

        bSkipSampleRate = false;
        bHasSampleRate = false;

        bSkipPDTypeProbability = false;
        bHasPDTypeProbability = false;

        bSkipTriggerThreshold = false;
        bHasTriggerThreshold = false;

        bSkipOpenTime = false;
        bHasOpenTime = false;

        bSkipShutTime = false;
        bHasShutTime = false;

        bSkipMaxIntervalTime = false;
        bHasMaxIntervalTime = false;

        bSkipGain = false;
        bHasGain = false;

        bSkipSyncSource = false;
        bHasSyncSource = false;

        bSkipSyncState = false;
        bHasSyncState = false;

        bSkipSyncFrequency = false;
        bHasSyncFrequency = false;

        bSkipDischargeSeverity = false;
        bHasDischargeSeverity = false;
    }

    AEWaveExtInformationPrivate& AEWaveExtInformationPrivate::operator=(const AEWaveExtInformationPrivate& stAEWaveExtInformationPrivate)
    {
        this->ucAmpUnit = stAEWaveExtInformationPrivate.ucAmpUnit;
        this->fAmpLowerLimit = stAEWaveExtInformationPrivate.fAmpLowerLimit;
        this->fAmpUpperLimit = stAEWaveExtInformationPrivate.fAmpUpperLimit;
        this->ucAESensorType = stAEWaveExtInformationPrivate.ucAESensorType;
        this->iDataPoint = stAEWaveExtInformationPrivate.iDataPoint;
        this->llSampleRate = stAEWaveExtInformationPrivate.llSampleRate;
        this->vecPDTypeProbability = stAEWaveExtInformationPrivate.vecPDTypeProbability;
        this->fTriggerThreshold = stAEWaveExtInformationPrivate.fTriggerThreshold;
        this->sOpenTime = stAEWaveExtInformationPrivate.sOpenTime;
        this->sShutTime = stAEWaveExtInformationPrivate.sShutTime;
        this->sMaxIntervalTime = stAEWaveExtInformationPrivate.sMaxIntervalTime;
        this->sGain = stAEWaveExtInformationPrivate.sGain;
        this->ucSyncSource = stAEWaveExtInformationPrivate.ucSyncSource;
        this->ucSyncState = stAEWaveExtInformationPrivate.ucSyncState;
        this->fSyncFrequency = stAEWaveExtInformationPrivate.fSyncFrequency;
        this->ucDischargeSeverity = stAEWaveExtInformationPrivate.ucDischargeSeverity;
        return *this;
    }

    bool AEWaveExtInformationPrivate::operator==(const AEWaveExtInformationPrivate& stAEWaveExtInformationPrivate) const
    {
        if (!(this->ucAmpUnit == stAEWaveExtInformationPrivate.ucAmpUnit)) return false;
        if (!qFuzzyCompare(this->fAmpLowerLimit, stAEWaveExtInformationPrivate.fAmpLowerLimit)) return false;
        if (!qFuzzyCompare(this->fAmpUpperLimit, stAEWaveExtInformationPrivate.fAmpUpperLimit)) return false;
        if (!(this->ucAESensorType == stAEWaveExtInformationPrivate.ucAESensorType)) return false;
        if (!(this->iDataPoint == stAEWaveExtInformationPrivate.iDataPoint)) return false;
        if (!(this->llSampleRate == stAEWaveExtInformationPrivate.llSampleRate)) return false;
        if (!(this->vecPDTypeProbability == stAEWaveExtInformationPrivate.vecPDTypeProbability)) return false;
        if (!qFuzzyCompare(this->fTriggerThreshold, stAEWaveExtInformationPrivate.fTriggerThreshold)) return false;
        if (!(this->sOpenTime == stAEWaveExtInformationPrivate.sOpenTime)) return false;
        if (!(this->sShutTime == stAEWaveExtInformationPrivate.sShutTime)) return false;
        if (!(this->sMaxIntervalTime == stAEWaveExtInformationPrivate.sMaxIntervalTime)) return false;
        if (!(this->sGain == stAEWaveExtInformationPrivate.sGain)) return false;
        if (!(this->ucSyncSource == stAEWaveExtInformationPrivate.ucSyncSource)) return false;
        if (!(this->ucSyncState == stAEWaveExtInformationPrivate.ucSyncState)) return false;
        if (!qFuzzyCompare(this->fSyncFrequency, stAEWaveExtInformationPrivate.fSyncFrequency)) return false;
        if (!(this->ucDischargeSeverity == stAEWaveExtInformationPrivate.ucDischargeSeverity)) return false;
        return true;
    }

    AEWaveDataPrivate::AEWaveDataPrivate()
    {
        bSkipAEWaveSpectrumData = false;
        bHasAEWaveSpectrumData = false;
    }

    AEWaveDataPrivate& AEWaveDataPrivate::operator=(const AEWaveDataPrivate& stAEWaveDataPrivate)
    {
        this->qbaAEWaveData = stAEWaveDataPrivate.qbaAEWaveData;
        return *this;
    }

    bool AEWaveDataPrivate::operator==(const AEWaveDataPrivate& stAEWaveDataPrivate) const
    {
        if (!(this->qbaAEWaveData == stAEWaveDataPrivate.qbaAEWaveData)) return false;
        return true;
    }
}
